• Why Functions?
  • Code Repetition & DRY principle
• What are Functions?
  • Reusable Blocks (def)
• Function Syntax
  • Anatomy & Examples
• Function Arguments
  • Positional, Keyword, Default
• Lambda Functions
  • Anonymous, One-liners
• Variable Scope
  • Local & Global Scope
• Best Practices & Pitfalls
  • Naming, Docstrings, Indentation, return
• Summary & Q&A
  • Recap & Next Steps

• We pass arguments to functions to make them flexible
• There are two ways to pass arguments: positional and keyword arguments
• Positional arguments are passed in the order the parameters are defined
• Let’s see an example:

def get_greeting(name, greeting_type="Hello"):
    message = f"{greeting_type}, {name}! Nice to see you."
    return message

message = get_greeting("Alice", "Hi")
print(message)

Hi, Alice! Nice to see you.

• This function is almost identical to the previous one
• It looks fine, right? Try to run it and see what happens!

def greet_incorrect(greeting_type="Hello", name):
    message = f"{greeting_type}, {name}!"
    return message

• What’s the error message? 🚨

  Cell In[14], line 1
    def greet_incorrect(greeting_type="Hello", name): 
                                               ^
SyntaxError: parameter without a default follows parameter with a default

• Sometimes you don’t need a full function definition
• Just a simple, one-line function is enough
• ️Lambda functions are perfect for this!
  • They can have many arguments but only one expression (no return statement)
  • They are also known as anonymous functions, but can be assigned to a variable
• Syntax: lambda arguments: expression
  • lambda x, y: x + y

• Python has a concept called variable scope
• Scope means: Where in your code can you use a variable? 🤔

• First, let’s understand local variables:
  • They are called local because they are “local” to the function
  • They only exist and can be used within that function’s body
  • They are not accessible from outside the function
• Think of it like a private workspace:
  • But once the function finishes, that workspace (and its local variables) disappears!

• Now, let’s look at global variables:
  • Variables defined outside of any function (at the top level of your code) are called global variables
  • They can be accessed from anywhere in your code, including inside functions!
• Think of it like shared information for your whole program:
  • Any part of your code can see and use global variables

• If you want to change a global variable inside a function, you need to use the global keyword

• This tells Python: “Hey, I’m talking about the global variable here!”

• Let’s see an example:

global_greeting = "Welcome!"

def change_greeting(new_greeting):
    global global_greeting
    global_greeting = new_greeting

change_greeting("Hello!")
print(global_greeting) # Now it works!

Hello!

• Docstrings are multi-line comments that describe what your function does
• They are enclosed in triple quotes (""" or ''')
• They should include:
  • Function purpose
  • Parameters and return values
  • Additional information if needed
• They help others (and you!) understand your code
• Good documentation is a great way to ensure your code is maintainable

• You all know that Python is indentation-sensitive
• It’s not to make your code look pretty, but to define the structure of your code
• Incorrect indentation = IndentationError!
  • Python will complain loudly if your indentation is wrong 😅

# No indentation!
def my_function():
print("Hello!")

# Good code!
def my_function():
    print("Hello!")

• Return and print are not the same!
• Return sends a value back to the caller
• Print displays a value on the screen

• Common mistake 1: Using print instead of return

def double(x):
    print(x * 2)

# Good code! Use return!
def double(x):
    return x * 2

• Functions are mini-programs that perform a specific task
• They help you avoid code repetition and keep your code clean

• Function anatomy:
  • def keyword, name, parameters, body, return, and indentation
  • Positional vs keyword arguments
  • Default values

• Global vs local variables:
  • Local variables are only accessible inside the function
  • Global variables can be accessed from anywhere
  • Use global keyword to change global variables inside functions

• Best practices:
  • Naming conventions
  • Docstrings
  • Indentation
  • Return vs print

• Pitfalls to avoid:
  • Indentation errors
  • Missing return statements
  • Global vs local variables
  • Using print instead of return
  • Using return inside loops or if statements
  • Mixing spaces and tabs

• Some readings you may find useful:
  • Python Functions
  • Python Lambda Functions
  • Python Scope and the LEGB Rule
  • PEP 8 - Style Guide for Python Code
  • Python Docstrings
• Online courses:
  • Coursera
  • edX
  • Udemy
  • Codecademy
  • DataCamp

• The course introduces students to data analysis with Python and SQL
• It covers:
  • Data manipulation with Pandas and NumPy
  • Data visualisation with Matplotlib
  • Writing and running functions
  • Time series and panel data analysis
  • Introduction to SQL for data retrieval
  • Jupyter Notebooks and reproducible research
• All materials are free and openly available

• The course introduces students to modern data science and engineering, focusing on reliability, reproducibility, and robustness
• The course covers:
  • Command line interface
  • Version control with git and GitHub (using the terminal)
  • Literate programming with Quarto
  • AI-assisted programming
  • Introduction to cloud computing
  • Data storage and retrieval with SQL
  • Parallel computing with Dask
  • Containers and reproducible workflows with Docker
• All materials are also free and openly available

• QTM 385 is a course on experimental methods in the social and health sciences
• The main topics covered are:
  • The logic of causal inference
  • Randomisation procedures
  • Blocking and clustering
  • Pre-analysis plans and registered reports
  • Power calculations
  • Non-compliance and attrition
  • Survey experiments
  • Research ethics
• As with the other courses, all materials are available online

• The LEGB rule is a way to understand how Python looks for variables
• It stands for:
  • Local: Variables defined inside a function
  • Enclosing: Variables in the local scope of enclosing functions
  • Global: Variables defined at the top level of a module
  • Built-in: Predefined names in Python (e.g., print, len)
• Python will look for a variable in the local scope first, then in the enclosing functions, then in the global scope, and finally in the built-in scope

def outer_function():
    x = 10
    def inner_function():
        y = 5
        return x + y
    return inner_function()

print(outer_function())

15

• Here, x is in the enclosing scope of inner_function, so it can access it

• Let’s see something a bit more advanced! 😅
• *args and **kwargs are great tools for writing flexible functions

*args: Packing Positional Arguments

• What if you want a function that accepts a variable number of positional arguments?
• *args has got you covered! It:
  • Collects extra positional arguments into a tuple called args
  • Allows your function to be called with any number of positional arguments
• Think of it as: *args = “arguments” (with a star to make it special!)

• Error handling is a way to manage errors that may occur during the execution of your code
• It helps you handle unexpected situations gracefully
• You can use try and except blocks to catch and handle errors
• Imagine accessing items in a list… but what if you ask for too much? 🤔

def get_list_item_safe(my_list, index):
    """
    Safely gets an item from a list at a given index,
    handling IndexError.
    """
    try:
        item = my_list[index]
        return item
    except IndexError:
        return "Error: Index is out of range!"

my_list = ["apple", "banana", "cherry"]

print(get_list_item_safe(my_list, 1))  
print(get_list_item_safe(my_list, 5))  

banana
Error: Index is out of range!